home *** CD-ROM | disk | FTP | other *** search
/ Amiga Developer CD 2.1 / Amiga Developer CD v2.1.iso / Reference / Amiga_Mail_Vol2 / IV-41 / mytextlabelclass.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-27  |  12.8 KB  |  488 lines
  1. /*
  2. Copyright (c) 1991-1999 Amiga, Inc.
  3.  
  4. This example is provided in electronic form by Amiga, Inc.
  5. for use with the Amiga Mail Volume II technical publication.
  6. Amiga Mail Volume II contains additional information on the correct
  7. usage of the techniques and operating system functions presented in
  8. these examples.  The source and executable code of these examples may
  9. only be distributed in free electronic form, via bulletin board or
  10. as part of a fully non-commercial and freely redistributable
  11. diskette.  Both the source and executable code (including comments)
  12. must be included, without modification, in any copy.  This example
  13. may not be published in printed form or distributed with any
  14. commercial product. However, the programming techniques and support
  15. routines set forth in these examples may be used in the development
  16. of original executable software products for Amiga
  17. computers.
  18.  
  19. All other rights reserved.
  20.  
  21. This example is provided "as-is" and is subject to change; no
  22. warranties are made.  All use is at your own risk. No liability or
  23. responsibility is assumed.
  24.  *
  25.  * Written by David N. Junod
  26.  *
  27.  * Compiled with SAS/C 6.56 sc NMINC STRMERGE OPTSIZE OPTIMIZE OPTGLOBAL NOSTKCHK
  28.  * (must be linked with classface.o and hookface.o)
  29.  *
  30.  * The Image structure as used by this class:
  31.  *
  32.  * struct Image {
  33.  *
  34.  * SHORT    LeftEdge;        <----Offset relative to the container
  35.  * SHORT    TopEdge;
  36.  *
  37.  * SHORT    Width;           <----Contains the text extent of the string
  38.  * SHORT    Height;
  39.  *
  40.  * SHORT    Depth;           <----Maintained by boopsi (must be set to CUSTOMIMAGEDEPTH).
  41.  *
  42.  * USHORT   *ImageData;      <----Pointer to a NULL terminated text string
  43.  *
  44.  * UBYTE    PlanePick;       <----We use this for the foreground color
  45.  *
  46.  * UBYTE    PlaneOnOff;      <----We use this for the background color
  47.  *
  48.  * struct Image *NextImage;  <----Pointer to the next image.  Handled by DrawImage(). };
  49.  */
  50.  
  51.  
  52. #include <exec/types.h>
  53. #include <exec/memory.h>
  54. #include <exec/libraries.h>
  55. #include <intuition/intuition.h>
  56. #include <intuition/classes.h>
  57. #include <intuition/classusr.h>
  58. #include <intuition/cghooks.h>
  59. #include <intuition/gadgetclass.h>
  60. #include <intuition/imageclass.h>
  61. #include <intuition/icclass.h>
  62. #include <intuition/screens.h>
  63. #include <graphics/gfx.h>
  64. #include <graphics/gfxmacros.h>
  65. #include <libraries/gadtools.h>
  66. #include <utility/tagitem.h>
  67. #include <clib/macros.h>
  68. #include <clib/exec_protos.h>
  69. #include <clib/intuition_protos.h>
  70. #include <clib/graphics_protos.h>
  71. #include <clib/utility_protos.h>
  72. #include <string.h>
  73.  
  74. extern struct Library *SysBase, *DOSBase;
  75. extern struct Library *IntuitionBase, *GfxBase, *UtilityBase;
  76.  
  77. /*
  78.  * Because we are dealing with imageclass objects, the data structure that makes up the
  79.  * object is an intuition Image structure.
  80.  */
  81. #define IM(o)   ((struct Image *)(o))
  82.  
  83. #define MYCLASSID       NULL
  84. #define SUPERCLASSID    (IMAGECLASS)
  85.  
  86. Class          *initmyTextLabelClass(VOID);
  87. ULONG           freemyTextLabelClass(Class * cl);
  88. ULONG __saveds  dispatchmyTextLabel(Class * cl, Object * o, Msg msg);
  89. ULONG           setmyTextLabelAttrs(Class * cl, Object * o, struct opSet * msg);
  90. ULONG           getmyTextLabelAttr(Class * cl, Object * o, struct opGet * msg);
  91. ULONG           drawmyTextLabel(Class * cl, Object * o, struct impDraw * msg);
  92. WORD            aTextExtent(struct RastPort *, STRPTR, LONG, struct TextExtent *);
  93. UWORD           GetLabelKeystroke(STRPTR label);
  94. static VOID     getContentsExtent(Class * cl, Object * o, struct DrawInfo * drinfo);
  95.  
  96. /* prototypes of functions from classface.o */
  97. ULONG           DoMethod(Object * o, ULONG methodID,...);
  98. ULONG           DoSuperMethod(Class * cl, Object * o, ULONG methodID,...);
  99. ULONG           CoerceMethod(Class * cl, Object * o, ULONG methodID,...);
  100. ULONG           CM(Class * cl, Object * o, Msg msg);
  101. ULONG           DM(Object * o, Msg msg);
  102. ULONG           DSM(Class * cl, Object * o, Msg msg);
  103. ULONG           SetSuperAttrs(Class * cl, Object * o, ULONG data,...);
  104.  
  105. struct localObjData
  106. {
  107.     /* Font to use */
  108.     struct TextFont *lod_Font;
  109.  
  110.     /* The key that is underlined */
  111.     UWORD           lod_Key;
  112.  
  113.     /* DrawMode */
  114.     UBYTE           lod_Mode;
  115. };
  116.  
  117.  
  118. Class          *
  119. initmyTextLabelClass(VOID)
  120. {
  121.     ULONG           hookEntry(); /* from hookface.o */
  122.     Class          *cl;
  123.  
  124.     if (cl = MakeClass(MYCLASSID,
  125.                        SUPERCLASSID, NULL,
  126.                        sizeof(struct localObjData), 0))
  127.     {
  128.         /* Fill in the callback hook */
  129.         cl->cl_Dispatcher.h_Entry = hookEntry;
  130.         cl->cl_Dispatcher.h_SubEntry = dispatchmyTextLabel;
  131.     }
  132.     /* Return a pointer to the class */
  133.     return (cl);
  134. }
  135.  
  136.  
  137. ULONG
  138. freemyTextLabelClass(Class * cl)
  139. {
  140.  
  141.     /* Try to free the public class */
  142.     return ((ULONG) FreeClass(cl));
  143. }
  144.  
  145.  
  146. /*
  147.  * The SAS "__saveds" flag tells the SAS compiler to put
  148.  * the data storage address + 32766 into A4.
  149.  */
  150. ULONG           __saveds
  151. dispatchmyTextLabel(Class * cl, Object * o, Msg msg)
  152. {
  153.     struct localObjData *lod;
  154.     Object         *newobj;
  155.     ULONG           retval;
  156.  
  157.     switch (msg->MethodID)
  158.     {
  159.     case OM_NEW:
  160.         /* Pass up to the superclass... */
  161.         if (newobj = (Object *) DSM(cl, o, msg))
  162.         {
  163.             struct TagItem *attrs = ((struct opSet *) msg)->ops_AttrList;
  164.             struct DrawInfo *drinfo;
  165.  
  166.             /* Get the DrawInfo */
  167.             drinfo = (struct DrawInfo *) GetTagData(SYSIA_DrawInfo, NULL, attrs);
  168.  
  169.             /* Get the instance data */
  170.             lod = INST_DATA(cl, newobj);
  171.  
  172.             /* Establish defaults */
  173.             IM(newobj)->PlanePick = 1;
  174.             lod->lod_Mode = JAM1;
  175.  
  176.             /* Set the attributes */
  177.             setmyTextLabelAttrs(cl, newobj, (struct opSet *) msg);
  178.  
  179.             /* Get the bounding rectangle of the label */
  180.             getContentsExtent(cl, newobj, drinfo);
  181.         }
  182.         retval = (ULONG) newobj;
  183.         break;
  184.  
  185.     case OM_GET:
  186.         retval = getmyTextLabelAttr(cl, o, (struct opGet *) msg);
  187.         break;
  188.  
  189.     case OM_UPDATE:
  190.     case OM_SET:
  191.         /* Do the superclass first */
  192.         retval = DSM(cl, o, msg);
  193.  
  194.         /* Call our set routines */
  195.         retval += setmyTextLabelAttrs(cl, o, (struct opSet *) msg);
  196.         break;
  197.  
  198.     case IM_DRAW:               /* draw the label */
  199.     case IM_DRAWFRAME:          /* drawmyTextLabel() will take care of
  200.                                    extra framing info */
  201.         retval = drawmyTextLabel(cl, o, (struct impDraw *) msg);
  202.         break;
  203.  
  204.     /* Let the superclass handle everything else */
  205.     default:
  206.         retval = (ULONG) DSM(cl, o, msg);
  207.         break;
  208.     }
  209.  
  210.     return (retval);
  211. }
  212.  
  213.  
  214. /* Set attributes of an object */
  215. ULONG
  216. setmyTextLabelAttrs(Class * cl, Object * o, struct opSet * msg)
  217. {
  218.     struct localObjData *lod = INST_DATA(cl, o);
  219.     struct TagItem *tags = msg->ops_AttrList;
  220.     struct TagItem *tstate;
  221.     struct TagItem *tag;
  222.     ULONG           tidata;
  223.  
  224.     /* process rest */
  225.     tstate = tags;
  226.     while (tag = NextTagItem(&tstate))
  227.     {
  228.         tidata = tag->ti_Data;
  229.         switch (tag->ti_Tag)
  230.         {
  231.         case IA_FGPen:
  232.             IM(o)->PlanePick = (UBYTE) tidata;
  233.             break;
  234.  
  235.         case IA_BGPen:
  236.             IM(o)->PlaneOnOff = (UBYTE) tidata;
  237.             break;
  238.  
  239.             /* Must be a TextFont pointer. */
  240.         case IA_Font:
  241.             /* Set the font */
  242.             lod->lod_Font = (struct TextFont *) tidata;
  243.             break;
  244.  
  245.             /* Drawing mode to use */
  246.         case IA_Mode:
  247.             lod->lod_Mode = (UBYTE) tidata;
  248.             break;
  249.  
  250.         case IA_Data:
  251.             IM(o)->ImageData = (USHORT *) tidata;
  252.             lod->lod_Key = GetLabelKeystroke((STRPTR) tidata);
  253.             break;
  254.         }
  255.     }
  256.  
  257.     return (1L);
  258. }
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265. /* Inquire attributes of an object */
  266. ULONG
  267. getmyTextLabelAttr(Class * cl, Object * o, struct opGet * msg)
  268. {
  269.     struct localObjData *lod = INST_DATA(cl, o);
  270.  
  271.     switch (msg->opg_AttrID)
  272.     {
  273.     case IA_Font:
  274.         *msg->opg_Storage = (ULONG) lod->lod_Font;
  275.         break;
  276.  
  277.     case IA_Mode:
  278.         *msg->opg_Storage = (ULONG) lod->lod_Mode;
  279.         break;
  280.  
  281.         /* Let the superclass try */
  282.     default:
  283.         return ((ULONG) DSM(cl, o, msg));
  284.     }
  285.  
  286.     return (1L);
  287. }
  288.  
  289.  
  290. ULONG
  291. drawmyTextLabel(Class * cl, Object * o, struct impDraw * msg)
  292. {
  293.     struct localObjData *lod = INST_DATA(cl, o);
  294.     STRPTR          label = (STRPTR) IM(o)->ImageData;
  295.     struct DrawInfo *di = msg->imp_DrInfo;
  296.     struct RastPort *rp = msg->imp_RPort;
  297.     struct TextFont *tf = NULL;
  298.     WORD            len = strlen(label);
  299.     WORD            left, top;
  300.     WORD            height = 0;
  301.     WORD            width = 0;
  302.     WORD            i;
  303.  
  304.     /* Clear the key */
  305.     lod->lod_Key = NULL;
  306.  
  307.     /* Get a pointer to the font to use */
  308.     if (!(tf = lod->lod_Font) && di)
  309.     {
  310.         tf = di->dri_Font;
  311.     }
  312.  
  313.     /* Make sure we have font pointer */
  314.     if (tf)
  315.     {
  316.         /* Set the font */
  317.         SetFont(rp, tf);
  318.     }
  319.     /* Figure out our coordinates */
  320.     top = msg->imp_Offset.Y + IM(o)->TopEdge + rp->TxBaseline;
  321.     left = msg->imp_Offset.X + IM(o)->LeftEdge;
  322.  
  323.     /* See if we have frame information. */
  324.     if (msg->MethodID == IM_DRAWFRAME)
  325.     {
  326.         /* Center the text inside the frame. */
  327.         width = msg->imp_Dimensions.Width;
  328.         height = msg->imp_Dimensions.Height;
  329.         top += ((height - IM(o)->Height) > 0) ? ((height - IM(o)->Height) / 2) : 0;
  330.         left += ((width - IM(o)->Width) > 0) ? ((width - IM(o)->Width) / 2) : 0;
  331.     }
  332.  
  333.     /* Set the colors */
  334.     SetAPen(rp, IM(o)->PlanePick);
  335.     SetBPen(rp, IM(o)->PlaneOnOff);
  336.  
  337.     /* Set the drawing mode */
  338.     SetDrMd(rp, lod->lod_Mode);
  339.  
  340.     /* Move to the start */
  341.     Move(rp, left, top);
  342.  
  343.  
  344.  
  345.     /* Step through string */
  346.     for (i = 0; i < (len - 1); i++)
  347.     {
  348.         /* Is this an '_' ? */
  349.         if (label[i] == '_')
  350.         {
  351.             WORD            bot = (top + rp->TxHeight - rp->TxBaseline);
  352.             WORD            mark;
  353.  
  354.             /* Draw the first part of the string */
  355.             Text(rp, label, i);
  356.  
  357.             /* Remember where we are in the string */
  358.             mark = rp->cp_x;
  359.  
  360.             /* Draw the underscore */
  361.             Move(rp, mark, bot);
  362.             Draw(rp, (mark + TextLength(rp, &label[(i + 1)], 1L) - 2), bot);
  363.  
  364.             /* Return to where we were */
  365.             Move(rp, mark, top);
  366.  
  367.             /*
  368.              * Draw the rest of the string.  This one is done last so that the cursor
  369.              * could be positioned after the text.
  370.              */
  371.             Text(rp, &label[(i + 1)], (len - i - 1));
  372.  
  373.             /* Return the underlined character */
  374.             lod->lod_Key = (UWORD) label[i];
  375.         }
  376.     }
  377.  
  378.     /* Do we have an underscore? */
  379.     if (!lod->lod_Key)
  380.     {
  381.         /* Didn't find an '_' sign */
  382.         Text(rp, label, len);
  383.     }
  384.     return (1L);
  385. }
  386.  
  387.  
  388. UWORD
  389. GetLabelKeystroke(STRPTR label)
  390. {
  391.     LONG            count = (label) ? strlen(label) : 0L;
  392.     LONG            i;
  393.  
  394.     /* Search for an _ sign */
  395.     for (i = 0; i < (count - 1); i++)
  396.     {
  397.         /* Did we find an _ sign? */
  398.         if (label[i] == '_')
  399.         {
  400.             return ((UWORD) label[(i + 1)]);
  401.         }
  402.     }
  403.  
  404.     return (0);
  405. }
  406.  
  407.  
  408. /* TextExtent that honors the '_' as being a non-printable character (once) */
  409. WORD
  410. aTextExtent(struct RastPort * rp, STRPTR string, LONG count, struct TextExtent * te)
  411. {
  412.     WORD retval = FALSE;
  413.     STRPTR buffer;
  414.     LONG i;
  415.  
  416.     /* Allocate a temporary buffer */
  417.     if (buffer = AllocVec ((count + 1), MEMF_CLEAR))
  418.     {
  419.     /* Step through string */
  420.     for (i = 0; i < count; i++)
  421.     {
  422.             /* Is this an '_' sign? */
  423.             if (string[i] == '_')
  424.             {
  425.         /* Add the rest of the label to the buffer */
  426.         strcat (buffer, &string[(i + 1)]);
  427.  
  428.         /* Adjust the length of the string. */
  429.         count--;
  430.         break;
  431.         }
  432.         else
  433.         {
  434.         /* Copy each character over, until we reach the _ mark */
  435.         buffer[i] = string[i];
  436.         }
  437.         }
  438.  
  439.         /* Get the extent */
  440.         TextExtent(rp, buffer, count, te);
  441.  
  442.     /* Free the temporary buffer */
  443.     FreeVec (buffer);
  444.  
  445.     /* Show that we were successful */
  446.     retval = TRUE;
  447.     }
  448.  
  449.     /* Return whatever textextent returned */
  450.     return (retval);
  451. }
  452.  
  453. static          VOID
  454. getContentsExtent(Class * cl, Object * o, struct DrawInfo * drinfo)
  455. {
  456.     struct localObjData *lod = INST_DATA(cl, o);
  457.     struct TextExtent te =
  458.     {NULL};
  459.     struct RastPort rp;
  460.     STRPTR          label;
  461.  
  462.     /* maybe look at some flags to handle other types of text someday */
  463.     if (label = (STRPTR) IM(o)->ImageData)
  464.     {
  465.         /* Initialize the RastPort */
  466.         InitRastPort(&rp);
  467.  
  468.         if (lod->lod_Font)
  469.         {
  470.             SetFont(&rp, lod->lod_Font);
  471.         }
  472.         else if (drinfo && drinfo->dri_Font)
  473.         {
  474.             SetFont(&rp, drinfo->dri_Font);
  475.         }
  476.         /* Get the rectangle for the label */
  477.         aTextExtent(&rp, label, strlen(label), &te);
  478.  
  479.         /* Set the image structure */
  480.         IM(o)->Width = te.te_Width;
  481.         IM(o)->Height = te.te_Height;
  482.     }
  483.     else
  484.     {
  485.         IM(o)->Width = IM(o)->Height = 0;
  486.     }
  487. }
  488.